package com.chen.concurrent.jmm;

/**
 * final 防止子类重写
 */
public final class SingletonTest {

    private static SingletonTest instance;

    private static final SingletonTest instance2 = new SingletonTest();


    /**
     * 防止创建，统一单例模式
     *
     * 防止不了反射
     */
    private SingletonTest(){}

    /**
     * 懒汉式
     *
     * @return
     */
    public static SingletonTest getInstance(){
        synchronized (SingletonTest.class){
            if(instance == null) {
                instance = new SingletonTest();
            }
        }
        return instance;
    }


    /**
     * double checked locking
     *
     * 如果2、3 发生了指令重排序（JVM JTI 指令重排优化）
     * 则 后面的线程 判断 instance ==null 则false，返回一个没有执行构造函数的 instance
     *
     * 构造方法内 有可能有一些初始化操作
     *
     * 解决方法 instance 增加 volatile修饰； 防止指令重排序；
     *
     * volatile 读写屏障；写屏障，写之前的代码不会跑到写之后；
     * @return
     */
    public static SingletonTest getInstance1(){
        if(instance == null){
            synchronized (SingletonTest.class){
                if(instance == null) {
                    /**
                     * 对应的指令
                     * 1、创建对象
                     * 2、调用构造方法
                     * 3、引用赋值给instance
                     */
                    instance = new SingletonTest();
                }
            }
        }
        return instance;
    }


    /**
     * 饿汉式
     *
     * @return
     */
    public static SingletonTest getInstance2(){
        return instance2;
    }


    /**
     * 静态内部类， 静态类本身就是懒加载
     *
     * @return
     */
    public static SingletonTest getInstance3(){
        return LazyHolder.instance;
    }

    private static final class LazyHolder{
        /**
         * JVM控制线程安全  static 只加载一次
         */
        static final SingletonTest instance = new SingletonTest();
    }


    //饿汉式
    enum Singleton{
        INSTANCE;
    }


}
